home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / plan / src / advmenu.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  11KB  |  363 lines
  1. /*
  2.  * Create and destroy the advance-warning popup. It is installed when the
  3.  * Advance icon (looks like a clock with two hands) is pressed. early_warn
  4.  * and/or late_warn in edit.entry are set to zero (off) or nonzero (on)
  5.  * when buttons in the Advance popup are pressed.
  6.  *
  7.  *    destroy_advance_popup()
  8.  *    create_advance_popup()
  9.  */
  10.  
  11. #include <stdio.h>
  12. #include <time.h>
  13. #include <Xm/Xm.h>
  14. #include <Xm/DialogS.h>
  15. #include <Xm/Form.h>
  16. #include <Xm/Frame.h>
  17. #include <Xm/RowColumn.h>
  18. #include <Xm/LabelP.h>
  19. #include <Xm/LabelG.h>
  20. #include <Xm/PushBP.h>
  21. #include <Xm/PushBG.h>
  22. #include <Xm/ToggleB.h>
  23. #include <Xm/Text.h>
  24. #include <Xm/Protocols.h>
  25. #include "cal.h"
  26.  
  27. static void        done_callback(), early_callback(),
  28.             early_text_callback(), late_callback(),
  29.             late_text_callback(), noalarm_callback();
  30. extern time_t        parse_datestring(), parse_timestring();
  31. extern char        *mktimestring();
  32. extern void        help_callback();
  33.  
  34. extern Display        *display;    /* everybody uses the same server */
  35. extern struct edit    edit;        /* info about entry being edited */
  36. extern struct config    config;        /* global configuration data */
  37. extern Pixel        color[NCOLS];    /* colors: COL_* */
  38. extern struct list    *mainlist;    /* list of all schedule entries */
  39.  
  40. static BOOL        have_shell;    /* message popup exists if TRUE */
  41. static Widget        shell;        /* popup menu shell */
  42. static Widget        early;        /* early-warning text */
  43. static Widget        early_toggle;    /* early-warning toggle button */
  44. static Widget        late;        /* late-warning text */
  45. static Widget        late_toggle;    /* late-warning toggle button */
  46. static Widget        noalarm_toggle;    /* no final alarm toggle button */
  47.  
  48.  
  49. /*
  50.  * destroy a popup. Remove it from the screen, and destroy its widgets.
  51.  * It's too much trouble to keep them for next time.
  52.  */
  53.  
  54. destroy_advance_popup()
  55. {
  56.     char            *string;    /* contents of text widget */
  57.  
  58.     if (have_shell && edit.editing) {
  59.         if (edit.entry.early_warn) {
  60.             string = XmTextGetString(early);
  61.             edit.entry.early_warn = parse_timestring(string);
  62.             XtFree(string);
  63.         }
  64.         if (edit.entry.late_warn) {
  65.             string = XmTextGetString(late);
  66.             edit.entry.late_warn = parse_timestring(string);
  67.             XtFree(string);
  68.         }
  69.         edit.changed = TRUE;
  70.         edit.entry.suspended = FALSE;
  71.         print_pixmap(edit.menu->entry[edit.y][SC_ADVANCE],
  72.                 edit.entry.early_warn || edit.entry.late_warn ?
  73.                             PIC_ADVANCE : -1);
  74.     }
  75.     if (have_shell) {
  76.         XtPopdown(shell);
  77.         XTDESTROYWIDGET(shell);
  78.         have_shell = FALSE;
  79.         confirm_new_entry();
  80.     }
  81. }
  82.  
  83.  
  84. /*
  85.  * create an advance-warning popup as a separate application shell. The
  86.  * popup is initialized with data from edit.entry.
  87.  */
  88.  
  89. create_advance_popup()
  90. {
  91.     Widget            form, rowcol, w, help;
  92.     register struct entry    *ep = &edit.entry;
  93.     Arg            args[20];
  94.     int            n;
  95.     Atom            closewindow;
  96.  
  97.     destroy_advance_popup();
  98.  
  99.     n = 0;
  100.     XtSetArg(args[n], XmNdeleteResponse,    XmDO_NOTHING);        n++;
  101.     XtSetArg(args[n], XmNiconic,        False);            n++;
  102.     shell = XtAppCreateShell("Advance Warnings", "plan",
  103.             applicationShellWidgetClass, display, args, n);
  104. #    ifdef EDITRES
  105.     XtAddEventHandler(shell, (EventMask)0, TRUE, 
  106.              _XEditResCheckMessages, NULL);
  107. #    endif
  108.     set_icon(shell, 1);
  109.     form = XtCreateManagedWidget("advform1", xmFormWidgetClass,
  110.             shell, NULL, 0);
  111.     XtAddCallback(form, XmNhelpCallback, help_callback, (XtPointer)"adv");
  112.  
  113.                             /*-- buttons --*/
  114.     n = 0;
  115.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  116.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  117.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  118.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  119.     XtSetArg(args[n], XmNwidth,        80);            n++;
  120.     w = XtCreateManagedWidget("Done", xmPushButtonWidgetClass,
  121.             form, args, n);
  122.     XtAddCallback(w, XmNactivateCallback, done_callback, (XtPointer)0);
  123.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  124.                                 "adv_done");
  125.  
  126.     n = 0;
  127.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  128.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  129.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  130.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  131.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  132.     XtSetArg(args[n], XmNwidth,        80);            n++;
  133.     help = XtCreateManagedWidget("Help", xmPushButtonWidgetClass,
  134.             form, args, n);
  135.     XtAddCallback(help, XmNactivateCallback, help_callback,
  136.                             (XtPointer)"adv");
  137.     XtAddCallback(help, XmNhelpCallback,     help_callback,
  138.                             (XtPointer)"adv");
  139.  
  140.                             /*-- frame --*/
  141.     n = 0;
  142.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  143.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  144.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  145.     XtSetArg(args[n], XmNbottomWidget,    w);            n++;
  146.     XtSetArg(args[n], XmNbottomOffset,    16);            n++;
  147.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  148.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  149.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  150.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  151.     XtSetArg(args[n], XmNshadowType,    XmSHADOW_ETCHED_IN);    n++;
  152.     w = XtCreateManagedWidget("", xmFrameWidgetClass,
  153.             form, args, n);
  154.     w = XtCreateManagedWidget("advform2", xmFormWidgetClass,
  155.             w, NULL, 0);
  156.     n = 0;
  157.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  158.     XtSetArg(args[n], XmNtopOffset,        10);            n++;
  159.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  160.     XtSetArg(args[n], XmNbottomOffset,    10);            n++;
  161.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  162.     XtSetArg(args[n], XmNrightOffset,    10);            n++;
  163.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  164.     XtSetArg(args[n], XmNleftOffset,    10);            n++;
  165.     XtSetArg(args[n], XmNspacing,        20);            n++;
  166.     XtSetArg(args[n], XmNpacking,        XmPACK_COLUMN);        n++;
  167.     XtSetArg(args[n], XmNnumColumns,    3);            n++;
  168.     rowcol = XtCreateManagedWidget("", xmRowColumnWidgetClass,
  169.             w, args, n);
  170.                             /*-- early, late --*/
  171.     n = 0;
  172.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  173.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  174.     XtSetArg(args[n], XmNset,        ep->early_warn != 0);    n++;
  175.     early_toggle = XtCreateManagedWidget("Early warning",
  176.             xmToggleButtonWidgetClass,
  177.             rowcol, args, n);
  178.     XtAddCallback(early_toggle, XmNvalueChangedCallback,
  179.                     early_callback, (XtPointer)0);
  180.     XtAddCallback(early_toggle, XmNhelpCallback,
  181.                     help_callback, (XtPointer)"adv_early");
  182.  
  183.     n = 0;
  184.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  185.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  186.     XtSetArg(args[n], XmNset,        ep->late_warn != 0);    n++;
  187.     late_toggle = XtCreateManagedWidget("Late warning",
  188.             xmToggleButtonWidgetClass,
  189.             rowcol, args, n);
  190.     XtAddCallback(late_toggle, XmNvalueChangedCallback,
  191.                     late_callback, (XtPointer)0);
  192.     XtAddCallback(late_toggle, XmNhelpCallback,
  193.                     help_callback, (XtPointer)"adv_late");
  194.  
  195.     n = 0;
  196.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  197.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  198.     XtSetArg(args[n], XmNset,        ep->noalarm == 0);    n++;
  199.     noalarm_toggle = XtCreateManagedWidget("Normal alarm",
  200.             xmToggleButtonWidgetClass,
  201.             rowcol, args, n);
  202.     XtAddCallback(noalarm_toggle, XmNvalueChangedCallback,
  203.                 noalarm_callback, (XtPointer)0);
  204.     XtAddCallback(noalarm_toggle, XmNhelpCallback,
  205.                 help_callback, (XtPointer)"adv_noalarm");
  206.  
  207.     n = 0;
  208.     XtSetArg(args[n], XmNwidth,        100);            n++;
  209.     XtSetArg(args[n], XmNrecomputeSize,    False);            n++;
  210.     XtSetArg(args[n], XmNpendingDelete,    True);            n++;
  211.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  212.     XtSetArg(args[n], XmNbackground,    color[COL_TEXTBACK]);    n++;
  213.     early = XtCreateManagedWidget("", xmTextWidgetClass,
  214.             rowcol, args, n);
  215.     XtAddCallback(early, XmNactivateCallback,
  216.                     early_text_callback, (XtPointer)NULL);
  217.     XtAddCallback(early, XmNhelpCallback,
  218.                     help_callback, (XtPointer)"adv_early");
  219.  
  220.     n = 0;
  221.     XtSetArg(args[n], XmNwidth,        100);            n++;
  222.     XtSetArg(args[n], XmNrecomputeSize,    False);            n++;
  223.     XtSetArg(args[n], XmNpendingDelete,    True);            n++;
  224.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  225.     XtSetArg(args[n], XmNbackground,    color[COL_TEXTBACK]);    n++;
  226.     late = XtCreateManagedWidget("", xmTextWidgetClass,
  227.             rowcol, args, n);
  228.     XtAddCallback(late, XmNactivateCallback,
  229.                     late_text_callback, (XtPointer)NULL);
  230.     XtAddCallback(late, XmNhelpCallback,
  231.                     help_callback, (XtPointer)"adv_late");
  232.  
  233.     n = 0;
  234.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  235.     XtCreateManagedWidget("", xmLabelWidgetClass,
  236.             rowcol, args, n);
  237.  
  238.     n = 0;
  239.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  240.     w = XtCreateManagedWidget("in advance", xmLabelWidgetClass,
  241.             rowcol, args, n);
  242.  
  243.     n = 0;
  244.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  245.     w = XtCreateManagedWidget("in advance", xmLabelWidgetClass,
  246.             rowcol, args, n);
  247.  
  248.     XtPopup(shell, XtGrabNone);
  249.     closewindow = XmInternAtom(display, "WM_DELETE_WINDOW", False);
  250.     XmAddWMProtocolCallback(shell, closewindow,
  251.                     done_callback, (XtPointer)shell);
  252.  
  253.     if (ep->early_warn)
  254.         print_text_button(early, mktimestring(ep->early_warn, TRUE));
  255.     if (ep->late_warn)
  256.         print_text_button(late, mktimestring(ep->late_warn, TRUE));
  257.  
  258.     have_shell = TRUE;
  259. }
  260.  
  261.  
  262. /*-------------------------------------------------- callbacks --------------*/
  263. /*
  264.  * All of these routines are direct X callbacks.
  265.  */
  266.  
  267. /*ARGSUSED*/
  268. static void done_callback(widget, item, data)
  269.     Widget                widget;
  270.     int                item;
  271.     XmToggleButtonCallbackStruct    *data;
  272. {
  273.     destroy_advance_popup();
  274. }
  275.  
  276.  
  277. /*ARGSUSED*/
  278. static void early_callback(widget, item, data)
  279.     Widget                widget;
  280.     int                item;
  281.     XmToggleButtonCallbackStruct    *data;
  282. {
  283.     if (data->set) {
  284.         XmProcessTraversal(early, XmTRAVERSE_CURRENT);
  285.         print_text_button(early,
  286.             mktimestring(edit.entry.early_warn = config.early_time,
  287.                                     TRUE));
  288.     } else {
  289.         edit.entry.early_warn = 0;
  290.         print_text_button(early, "");
  291.     }
  292.     edit.changed = TRUE;
  293.     sensitize_edit_buttons();
  294. }
  295.  
  296.  
  297. /*ARGSUSED*/
  298. static void early_text_callback(widget, item, data)
  299.     Widget                widget;
  300.     int                item;
  301.     XmToggleButtonCallbackStruct    *data;
  302. {
  303.     char                *text = XmTextGetString(widget);
  304.     Arg                args;
  305.  
  306.     config.early_time     =
  307.     edit.entry.early_warn = parse_timestring(text);
  308.     XtSetArg(args, XmNset, edit.entry.early_warn != 0);
  309.     XtSetValues(early_toggle, &args, 1);
  310.     print_text_button(widget, mktimestring(edit.entry.early_warn, TRUE));
  311.     XtFree(text);
  312. }
  313.  
  314.  
  315. /*ARGSUSED*/
  316. static void late_callback(widget, item, data)
  317.     Widget                widget;
  318.     int                item;
  319.     XmToggleButtonCallbackStruct    *data;
  320. {
  321.     if (data->set) {
  322.         XmProcessTraversal(late, XmTRAVERSE_CURRENT);
  323.         print_text_button(late,
  324.             mktimestring(edit.entry.late_warn = config.late_time,
  325.                                     TRUE));
  326.     } else {
  327.         edit.entry.late_warn = 0;
  328.         print_text_button(late, "");
  329.     }
  330.     edit.changed = TRUE;
  331.     sensitize_edit_buttons();
  332. }
  333.  
  334.  
  335. /*ARGSUSED*/
  336. static void late_text_callback(widget, item, data)
  337.     Widget                widget;
  338.     int                item;
  339.     XmToggleButtonCallbackStruct    *data;
  340. {
  341.     char                *text = XmTextGetString(widget);
  342.     Arg                args;
  343.  
  344.     config.late_time     =
  345.     edit.entry.late_warn = parse_timestring(text);
  346.     XtSetArg(args, XmNset, edit.entry.late_warn != 0);
  347.     XtSetValues(late_toggle, &args, 1);
  348.     print_text_button(widget, mktimestring(edit.entry.late_warn, TRUE));
  349.     XtFree(text);
  350. }
  351.  
  352.  
  353. /*ARGSUSED*/
  354. static void noalarm_callback(widget, item, data)
  355.     Widget                widget;
  356.     int                item;
  357.     XmToggleButtonCallbackStruct    *data;
  358. {
  359.     edit.entry.noalarm = !data->set;
  360.     edit.changed = TRUE;
  361.     sensitize_edit_buttons();
  362. }
  363.